"""
提示词调试器模块
支持在开发环境中直接测试和调试提示词
"""

import os
import json
import time
from typing import Dict, Any, List, Optional, Union
from datetime import datetime
import logging

from src.research_core.prompt_eng_agents import (
    advanced_evaluate_prompt_quality, 
    evaluate_prompt_quality,
    _initialize_components
)
from src.research_core.ab_testing import ABTester

# 创建 logger 实例
logger = logging.getLogger(__name__)

class PromptDebugger:
    """
    提示词调试器
    支持在开发环境中直接测试和调试提示词
    """
    
    def __init__(self):
        """初始化提示词调试器"""
        self.test_history = []
        self._initialize_llm()
    
    def _initialize_llm(self):
        """初始化LLM组件"""
        try:
            _initialize_components()
        except Exception as e:
            logger.warning(f"LLM初始化失败: {e}")
    
    def test_prompt(self, 
                    prompt: str, 
                    requirement: str = "", 
                    test_inputs: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
        """
        测试单个提示词
        
        Args:
            prompt: 要测试的提示词
            requirement: 相关需求描述
            test_inputs: 测试输入列表
            
        Returns:
            测试结果字典
        """
        logger.info(f"开始测试提示词: {prompt[:50]}...")
        
        # 记录开始时间
        start_time = time.time()
        
        # 执行评估
        basic_score = evaluate_prompt_quality(prompt)
        advanced_evaluation = advanced_evaluate_prompt_quality(prompt, requirement)
        
        # 准备测试结果
        test_result = {
            "prompt": prompt,
            "requirement": requirement,
            "test_inputs": test_inputs or [],
            "basic_score": basic_score,
            "advanced_evaluation": advanced_evaluation,
            "test_timestamp": datetime.now().isoformat(),
            "execution_time": time.time() - start_time
        }
        
        # 添加到测试历史
        self.test_history.append(test_result)
        
        logger.info(f"提示词测试完成，综合得分: {advanced_evaluation['overall_score']}")
        return test_result
    
    def compare_prompts(self, 
                       prompts: List[str], 
                       requirement: str = "",
                       test_inputs: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
        """
        比较多个提示词版本
        
        Args:
            prompts: 提示词列表
            requirement: 相关需求描述
            test_inputs: 测试输入列表
            
        Returns:
            比较结果字典
        """
        logger.info(f"开始比较 {len(prompts)} 个提示词版本")
        
        # 创建A/B测试器
        tester = ABTester()
        
        # 准备测试用例
        if not test_inputs:
            test_inputs = [{"input": "默认测试输入", "expected": "默认期望输出"}]
        
        # 执行比较
        try:
            results = tester.run_ab_test_sync(
                prompt_variants=prompts,
                test_cases=test_inputs
            )
            
            comparison_result = {
                "prompts": prompts,
                "requirement": requirement,
                "test_inputs": test_inputs,
                "ab_test_results": results,
                "comparison_timestamp": datetime.now().isoformat()
            }
            
            logger.info("提示词比较完成")
            return comparison_result
        except Exception as e:
            error_result = {
                "error": str(e),
                "prompts": prompts,
                "requirement": requirement,
                "test_inputs": test_inputs,
                "comparison_timestamp": datetime.now().isoformat()
            }
            logger.error(f"提示词比较失败: {e}")
            return error_result
    
    def interactive_debug(self, 
                         prompt: str, 
                         requirement: str = "") -> Dict[str, Any]:
        """
        交互式调试提示词
        
        Args:
            prompt: 要调试的提示词
            requirement: 相关需求描述
            
        Returns:
            调试结果字典
        """
        logger.info("开始交互式调试")
        
        # 执行测试
        test_result = self.test_prompt(prompt, requirement)
        
        # 生成调试建议
        suggestions = self._generate_debug_suggestions(test_result)
        
        debug_result = {
            "test_result": test_result,
            "debug_suggestions": suggestions,
            "debug_timestamp": datetime.now().isoformat()
        }
        
        logger.info("交互式调试完成")
        return debug_result
    
    def _generate_debug_suggestions(self, test_result: Dict[str, Any]) -> List[str]:
        """
        根据测试结果生成调试建议
        
        Args:
            test_result: 测试结果
            
        Returns:
            调试建议列表
        """
        suggestions = []
        advanced_eval = test_result.get("advanced_evaluation", {})
        
        # 根据各项评分生成建议
        if advanced_eval.get("clarity", 0) < 0.7:
            suggestions.append("提示词清晰度较低，建议使用更明确的指令词汇，避免模糊表达")
        
        if advanced_eval.get("completeness", 0) < 0.7:
            suggestions.append("提示词完整性不足，建议添加更多关键元素如目标、要求、输出格式等")
        
        if advanced_eval.get("specificity", 0) < 0.7:
            suggestions.append("提示词具体性不够，建议添加具体示例或约束条件")
        
        if advanced_eval.get("relevance", 0) < 0.7:
            suggestions.append("提示词与需求相关性较低，建议更紧密地结合需求描述")
        
        if advanced_eval.get("structuredness", 0) < 0.7:
            suggestions.append("提示词结构化程度不足，建议使用列表、编号等方式组织内容")
        
        # 如果没有具体建议，提供通用建议
        if not suggestions:
            suggestions.append("提示词质量良好，可以考虑在实际应用场景中进一步测试")
        
        return suggestions
    
    def save_test_result(self, 
                        test_result: Dict[str, Any], 
                        filepath: str) -> bool:
        """
        保存测试结果到文件
        
        Args:
            test_result: 测试结果
            filepath: 保存文件路径
            
        Returns:
            保存是否成功
        """
        try:
            # 确保目录存在
            os.makedirs(os.path.dirname(filepath), exist_ok=True)
            
            # 保存结果
            with open(filepath, 'w', encoding='utf-8') as f:
                json.dump(test_result, f, ensure_ascii=False, indent=2)
            
            logger.info(f"测试结果已保存到: {filepath}")
            return True
        except Exception as e:
            logger.error(f"保存测试结果失败: {e}")
            return False
    
    def load_test_result(self, filepath: str) -> Optional[Dict[str, Any]]:
        """
        从文件加载测试结果
        
        Args:
            filepath: 文件路径
            
        Returns:
            测试结果字典或None
        """
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                test_result = json.load(f)
            
            logger.info(f"测试结果已从 {filepath} 加载")
            return test_result
        except Exception as e:
            logger.error(f"加载测试结果失败: {e}")
            return None
    
    def get_test_history(self) -> List[Dict[str, Any]]:
        """
        获取测试历史
        
        Returns:
            测试历史列表
        """
        return self.test_history.copy()


def create_prompt_debugger() -> PromptDebugger:
    """
    创建提示词调试器实例
    
    Returns:
        PromptDebugger: 提示词调试器实例
    """
    return PromptDebugger()


# 导出类和函数
__all__ = [
    'PromptDebugger',
    'create_prompt_debugger'
]